package br.gov.sjc.XmlRead;

import org.w3c.dom.Document;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.os.Environment;
import android.util.Log;
import android.widget.Toast;
import br.gov.sjc.classes.DadosPessoais;
import br.gov.sjc.classes.Documentos;
import br.gov.sjc.classes.Endereco;
import br.gov.sjc.classes.Escolaridade;
import br.gov.sjc.classes.GrupoFamiliarTable;
import br.gov.sjc.classes.Nome;
import br.gov.sjc.export.EnviarArquivoFTP;
import br.gov.sjc.export.NomeArquivo;
import br.gov.sjc.export.exportarDados;
import br.gov.sjc.socialalimenta.Membro;
import br.gov.sjc.socialalimenta.SocialAlimentaApp;
import br.gov.sjc.socialalimenta.Trabalho;
import br.gov.sjc.socialalimenta.TrabalhoOFR;
import br.gov.sjc.socialalimenta.grupoFamiliar;
import br.gov.sjc.socialalimenta.dao.DadosPessoaisDAO;
import br.gov.sjc.socialalimenta.dao.DocumentosDAO;
import br.gov.sjc.socialalimenta.dao.EnderecoDAO;
import br.gov.sjc.socialalimenta.dao.EscolaridadeDAO;
import br.gov.sjc.socialalimenta.dao.GrupoFamiliarDAO;
import br.gov.sjc.socialalimenta.dao.MembroDAO;
import br.gov.sjc.socialalimenta.dao.NomeDAO;
import br.gov.sjc.socialalimenta.dao.TrabalhoDAO;
import br.gov.sjc.socialalimenta.dao.TrabalhoOFRDAO;
import br.org.sjc.validacao.DestroiDatabase;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Collection;


public class MainTest {
	private static int ID = 1;
	private static String TAG = "MainTest";
	// *** Inserido o Nome do Arquivo e Caminho

	private static File files = new File("/data/data/br.gov.sjc.socialalimenta/files/socialAlimenta.xml");
	private static String file = "/data/data/br.gov.sjc.socialalimenta/files/socialAlimenta.xml";
	private static Context context;

	// *** Salvar arquivo
	private static void salvarArquivo(String documento) throws Exception {
		Log.v(TAG, "salvarArquivo() Abriu");

		NomeArquivo na = new NomeArquivo(context);

		String NomeArquivo = "socialAlimenta-";
		//TODO: Chamando o ID = 1 (somente deve existir esse ID nessa tabela.
		NomeArquivo += na.PlacaPatrimonial(1);

		Log.i(TAG, "Nome do arquivo:"+NomeArquivo);


		try {
			//FileOutputStream fos = new FileOutputStream(file, true);
			FileOutputStream fos = context.openFileOutput(NomeArquivo+".xml",
					Context.MODE_APPEND);
			fos.write(documento.getBytes());
			fos.write("\r\n".getBytes());
			fos.flush();
			fos.close();
			Log.i(TAG, "salvarArquivo() close");
		}catch(Exception E){
			Log.e(TAG, "salvarArquivo() ERRO:"+E.getMessage());
		} 
	}

	/**
	 * Não USADO
	 * @param documento
	 * @param file
	 */
	private static void salvarArquivo2(String documento, String file) {

		File path = new File("/data/data/br.gov.sjc.socialalimenta/file/SocialAlimenta.xml");
		try {
			PrintWriter writer = new PrintWriter(path);
			writer.println(
					"<?xml version=\"1.0\" encoding=\"ISO-8859-1\" standalone=\"no\"?>"
					);            
			writer.println(documento);
			writer.flush();
			writer.close();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}     
	}

	/*
	 * Load file content to String
	 */
	public static String loadFileAsString(String filePath) throws java.io.IOException{
		StringBuffer fileData = new StringBuffer(1000);
		BufferedReader reader = new BufferedReader(new FileReader(filePath));
		char[] buf = new char[1024];
		int numRead=0;
		while((numRead=reader.read(buf)) != -1){
			String readData = String.valueOf(buf, 0, numRead);
			fileData.append(readData);
		}
		reader.close();
		return fileData.toString();
	}

	/*
	 * Get the STB MacAddress
	 */
	public static String getMacAddress(){
		try {
			String retorno;
			retorno = loadFileAsString("/sys/class/net/eth0/address")
					.toUpperCase().substring(0, 17);
			//retorno = InetAddress.getByName("127.0.0.1").getHostName();
			//String   tempString = retorno.replace( '.', '-' );
			return retorno;
		} catch (IOException e) {
			e.printStackTrace();
			return null;
		}
	}

	// *** Converter documento
	private static String converter(Document document) throws TransformerException {
		//Criamos uma instancia de Transformer
		//O método setOutputProperty cria a formata��o
		//ou Não do XML no arquivo. Se 'yes' ent�o formata,
		//se 'no' ent�o escreve o arquivo em uma �nica linha
		Transformer transformer = 
				TransformerFactory.newInstance().newTransformer();

		transformer.setOutputProperty(OutputKeys.INDENT, "yes");

		//inicializar StreamResult para gravar para String
		StreamResult result = new StreamResult(new StringWriter());
		DOMSource source = new DOMSource(document);
		transformer.transform(source, result);

		//Recupera o conte�do em formato String
		String xmlString = result.getWriter().toString();

		//Exibe o resultado da transforma��o
		System.out.append(xmlString);
		Log.v("MainTest", "converter Passou");

		//devolve a string
		return xmlString;
	}

	private static void gerarXmlXStream(Collection<grupoFamiliar> GF) throws Exception{
		Log.e("gerarXmlXStream", "Entrou");
		GF = new ArrayList<grupoFamiliar>();

		XStream xstream = new XStream();
		xstream.alias("SOCIALALIMENTA", SocialAlimentaApp.class);
		xstream.alias("GRUPOFAMILIAR", grupoFamiliar.class);
		xstream.alias("MEMBRO", Membro.class);
		xstream.alias("TRABALHO", Trabalho.class);
		xstream.alias("TRABALHOOFR", TrabalhoOFR.class);


		Log.e("gerarXmlXStream", "xstream.alias");

		SocialAlimentaApp SAapp2 = new SocialAlimentaApp();
		SAapp2.setrData("String Data de inserção");
		SAapp2.setrMatricula("String Matricula");
		SAapp2.setrNome("String Nome");
		SAapp2.setGrupoFamiliarCollection(GF);

		//xstream.addImplicitCollection(SocialAlimentaApp.class, "GRUPOSFAMILIARES");

		Log.e("gerarXmlXStream", "xstream.toXML");

		String xml = xstream.toXML(SAapp2);

		salvarArquivo(xml);
	}

	/**
	 * ESCREVE A ESTRUTURA DO XML
	 * @param SAApp
	 * @param nomeArquivo 
	 * @throws Exception
	 */
	private static void gerarXml(SocialAlimentaApp SAApp, String nomeArquivo) throws Exception {

		Log.v("SocialAlimenta", "gerarXml - Iniciou");

		//Criamos um nova instancia de DocumentBuilderFactory
		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		//Usamos o método newDocumentBuilder() para 
		//criar um nova instancia de DocumentBuilder
		DocumentBuilder dbuilder = dbf.newDocumentBuilder();
		//Obt�m uma nova inst�ncia de um Document 
		//objeto para construir uma �rvore com Document.
		Document doc = dbuilder.newDocument();
		Log.v("SocialAlimenta", "gerarXml - doc gerado");

		//*********************SOCIALALIMENTA************************************************

		Log.v("SocialAlimenta", "gerarXml - SOCIALALIMENTA iniciado");

		//Cria a tag raiz do XML que ser� SocialAlimenta
		Element tagSocialAlimenta = doc.createElement("SOCIALALIMENTA");

		Element tagrData = doc.createElement("RDATA");
		Element tagrNome = doc.createElement("RNOME");
		Element tagrMatricula = doc.createElement("RMATRICULA");



		// *********************GRUPOSFAMILIARES********************************************************

		Log.v("SocialAlimenta", "gerarXml - GRUPOSFAMILIARES iniciado");

		//Cria Elementos da Primeira Intera��o
		Element tagGruposFamiliares = doc.createElement("GRUPOSFAMILIARES");
		// *** geral
		tagrData.setTextContent(String.valueOf(SAApp.getrData()));
		tagrNome.setTextContent(String.valueOf(SAApp.getrNome()));
		tagrMatricula.setTextContent(String.valueOf(SAApp.getrMatricula()));

		//Insere na tag Contato as tags id, nome e email
		tagSocialAlimenta.appendChild(tagrData);
		tagSocialAlimenta.appendChild(tagrNome);
		tagSocialAlimenta.appendChild(tagrMatricula);


		// *** Geral
		Element SiasN; 
		// *** Endereco
		Element eEnd; 
		Element eNumero; 
		Element eAp; 
		Element eBloco; 
		Element eComplemento; 
		Element eReferencia; 
		Element eCEP; 
		Element eBairro; 
		// *** localizado
		Element lLocalizado; 
		Element lMudouse; 
		Element lEInexistente; 
		Element lSosam; 

		// *** AcessoAAlimentacao
		Element aaArrozFrequencia;
		Element aaArrozFormaAcesso;
		Element aaLeiteFrequencia;
		Element aaLeiteFormaAcesso;
		Element aaDerivadosFrequencia;
		Element aaDerivadosFormaAcesso;
		Element aaPaesFrequencia;
		Element aaPaesFormaAcesso;
		Element aaManteigaFrequencia;
		Element aaManteigaFormaAcesso;
		Element aaMacarraoFrequencia;
		Element aaMacarraoFormaAcesso;
		Element aaFubaFrequencia;
		Element aaFubaFormaAcesso;
		Element aaFrutasFrequencia;
		Element aaFrutasFormaAcesso;
		Element aaVerdurasFrequencia;
		Element aaVerdurasFormaAcesso;
		Element aaCarneFrequencia;
		Element aaCarneFormaAcesso;
		Element aaOvosFrequencia;
		Element aaOvosFormaAcesso;
		Element aaFarinhasFrequencia;
		Element aaFarinhasFormaAcesso;

		// *** IndSegAlimen
		Element isaGestante;
		Element isaGestanteAcompMedico;
		Element isaGestanteAcompNutric;
		Element isaNutriz;
		Element isaNutrizAcompMedico;
		Element isaNutrizAcompNutric;
		Element isaIntolerancia;
		Element isaIntoleranciaLactose;
		Element isaIntoleranciaGluten;
		Element isaIntoleranciaProteina;
		Element isaIntoleranciaOutra;
		Element isaIntoleranciaAcompMedico;
		Element isaIntoleranciaAcompNutric;
		Element isaDiabete;
		Element isaDiabeteAcompMedico;
		Element isaDiabeteAcompNutric;
		Element isaAnemia;
		Element isaAnemiaAcompMedico;
		Element isaAnemiaAcompNutric;
		Element isaHipertensao;
		Element isaHipertensaoAcompMedico;
		Element isaHipertensaoAcompNutric;
		Element isaObesidade;
		Element isaObesidadeAcompMedico;
		Element isaObesidadeAcompNutric;

		//Declara o grupo familiar criando o elemento
		Element tagGrupoFamiliar = null;

		Log.v("SocialAlimenta", "gerarXml - tagGrupoFamiliar FOR iniciado");

		for (grupoFamiliar SAA2 : SAApp.getGrupoFamiliarCollection() ) {


			// *** Cria a TAG do Grupo Familiar (cada um)
			tagGrupoFamiliar = doc.createElement("GRUPOFAMILIAR");

			// *** Atribui outras tags ao contexto
			// *** geral
			SiasN = doc.createElement("SIASN");
			// *** Endereco
			eEnd = doc.createElement("ENDERECO");
			eNumero = doc.createElement("NUMERO");
			eAp = doc.createElement("AP");
			eBloco = doc.createElement("BLOCO");
			eComplemento = doc.createElement("COMPLEMENTO");
			eReferencia = doc.createElement("REFERENCIA");
			eCEP = doc.createElement("CEP");
			eBairro = doc.createElement("BAIRRO");
			// *** localizado
			lLocalizado = doc.createElement("LOCALIZADO"); 
			lMudouse = doc.createElement("MUDOUSE"); 
			lEInexistente = doc.createElement("ENDINEX"); 
			lSosam = doc.createElement("SOSAM");
			// *** AcessoAAlimentacao
			aaArrozFrequencia = doc.createElement("ARROZFREQUENCIA");
			aaArrozFormaAcesso = doc.createElement("ARROZFORMAACESSO");
			aaLeiteFrequencia = doc.createElement("LEITEFREQUENCIA");
			aaLeiteFormaAcesso = doc.createElement("LEITEFORMAACESSO");
			aaDerivadosFrequencia = doc.createElement("DERIVADOSFREQUENCIA");
			aaDerivadosFormaAcesso = doc.createElement("DERIVADOSFORMAACESSO");
			aaPaesFrequencia = doc.createElement("PAESFREQUENCIA");
			aaPaesFormaAcesso = doc.createElement("PAESFORMAACESSO");
			aaManteigaFrequencia = doc.createElement("MANTEIGAFREQUENCIA");
			aaManteigaFormaAcesso = doc.createElement("MANTEIGAFORMAACESSO");
			aaMacarraoFrequencia = doc.createElement("MACARRAOFREQUENCIA");
			aaMacarraoFormaAcesso = doc.createElement("MACARRAOFORMAACESSO");
			aaFubaFrequencia = doc.createElement("FUBAFREQUENCIA");
			aaFubaFormaAcesso = doc.createElement("FUBAFORMAACESSO");
			aaFrutasFrequencia = doc.createElement("FRUTASFREQUENCIA");
			aaFrutasFormaAcesso = doc.createElement("FRUTASFORMAACESSO");
			aaVerdurasFrequencia = doc.createElement("VERDURASFREQUENCIA");
			aaVerdurasFormaAcesso = doc.createElement("VERDURASFORMAACESSO");
			aaCarneFrequencia = doc.createElement("CARNEFREQUENCIA");
			aaCarneFormaAcesso = doc.createElement("CARNEFORMAACESSO");
			aaOvosFrequencia = doc.createElement("OVOSFREQUENCIA");
			aaOvosFormaAcesso = doc.createElement("OVOSFORMAACESSO");
			aaFarinhasFrequencia = doc.createElement("FARINHASFREQUENCIA");
			aaFarinhasFormaAcesso = doc.createElement("FARINHASFORMAACESSO");
			// *** IndSegAlimen
			isaGestante = doc.createElement("GESTANTE");
			isaGestanteAcompMedico = doc.createElement("GESTANTEACOMPMEDICO");
			isaGestanteAcompNutric = doc.createElement("GESTANTEACOMPNUTRIC");
			isaNutriz = doc.createElement("NUTRIZ");
			isaNutrizAcompMedico = doc.createElement("NUTRIZACOMPMEDICO");
			isaNutrizAcompNutric = doc.createElement("NUTRIZACOMPNUTRIC");
			isaIntolerancia = doc.createElement("INTOLERANCIA");
			isaIntoleranciaLactose = doc.createElement("INTOLERANCIALACTOSE");
			isaIntoleranciaGluten = doc.createElement("INTOLERANCIAGLUTEN");
			isaIntoleranciaProteina = doc.createElement("INTOLERANCIAPROTEINA");
			isaIntoleranciaOutra = doc.createElement("INTOLERANCIAOUTRA");
			isaIntoleranciaAcompMedico = doc.createElement("INTOLERANCIAACOMPMEDICO");
			isaIntoleranciaAcompNutric = doc.createElement("INTOLERANCIAACOMPNUTRIC");
			isaDiabete = doc.createElement("DIABETE");
			isaDiabeteAcompMedico = doc.createElement("DIABETEACOMPMEDICO");
			isaDiabeteAcompNutric = doc.createElement("DIABETEACOMPNUTRIC");
			isaAnemia = doc.createElement("ANEMIA");
			isaAnemiaAcompMedico = doc.createElement("ANEMIAACOMPMEDICO");
			isaAnemiaAcompNutric = doc.createElement("ANEMIAACOMPNUTRIC");
			isaHipertensao = doc.createElement("HIPERTENSAO");
			isaHipertensaoAcompMedico = doc.createElement("HIPERTENSAOACOMPMEDICO");
			isaHipertensaoAcompNutric = doc.createElement("HIPERTENSAOACOMPNUTRIC");
			isaObesidade = doc.createElement("OBESIDADE");
			isaObesidadeAcompMedico = doc.createElement("OBESIDADEACOMPMEDICO");
			isaObesidadeAcompNutric = doc.createElement("OBESIDADEACOMPNUTRIC");

			//Insere os valores nas tags de GRUPOFAMILIAR
			// *** geral
			SiasN.setTextContent(String.valueOf(SAA2.getSiasN()));
			// *** Endereço
			eEnd.setTextContent(String.valueOf(SAA2.geteEndereco()));
			eNumero.setTextContent(String.valueOf(SAA2.geteNumero()));
			eAp.setTextContent(SAA2.geteAp());
			eBloco.setTextContent(SAA2.geteBloco());
			eComplemento.setTextContent(SAA2.geteComplemento());
			eReferencia.setTextContent(SAA2.geteReferencia());
			eCEP.setTextContent(SAA2.geteCEP());
			eBairro.setTextContent(SAA2.geteBairro());
			// *** localizado
			lLocalizado.setTextContent(String.valueOf(SAA2.getlLocalizado()));
			lMudouse.setTextContent(String.valueOf(SAA2.getlMudouse()));
			lEInexistente.setTextContent(SAA2.getlEInexistente());
			lSosam.setTextContent(SAA2.getlSosam());
			// *** AcessoAAlimentacao
			aaArrozFrequencia.setTextContent(String.valueOf(SAA2.getAaArrozFrequencia()));
			aaArrozFormaAcesso.setTextContent(String.valueOf(SAA2.getAaArrozFormaAcesso()));
			aaLeiteFrequencia.setTextContent(String.valueOf(SAA2.getAaLeiteFrequencia()));
			aaLeiteFormaAcesso.setTextContent(String.valueOf(SAA2.getAaLeiteFormaAcesso()));
			aaDerivadosFrequencia.setTextContent(String.valueOf(SAA2.getAaDerivadosFrequencia()));
			aaDerivadosFormaAcesso.setTextContent(String.valueOf(SAA2.getAaDerivadosFormaAcesso()));
			aaPaesFrequencia.setTextContent(String.valueOf(SAA2.getAaPaesFrequencia()));
			aaPaesFormaAcesso.setTextContent(String.valueOf(SAA2.getAaPaesFormaAcesso()));
			aaManteigaFrequencia.setTextContent(String.valueOf(SAA2.getAaManteigaFrequencia()));
			aaManteigaFormaAcesso.setTextContent(String.valueOf(SAA2.getAaManteigaFormaAcesso()));
			aaMacarraoFrequencia.setTextContent(String.valueOf(SAA2.getAaMacarraoFrequencia()));
			aaMacarraoFormaAcesso.setTextContent(String.valueOf(SAA2.getAaMacarraoFormaAcesso()));
			aaFubaFrequencia.setTextContent(String.valueOf(SAA2.getAaFubaFrequencia()));
			aaFubaFormaAcesso.setTextContent(String.valueOf(SAA2.getAaFubaFormaAcesso()));
			aaFrutasFrequencia.setTextContent(String.valueOf(SAA2.getAaFrutasFrequencia()));
			aaFrutasFormaAcesso.setTextContent(String.valueOf(SAA2.getAaFrutasFormaAcesso()));
			aaVerdurasFrequencia.setTextContent(String.valueOf(SAA2.getAaVerdurasFrequencia()));
			aaVerdurasFormaAcesso.setTextContent(String.valueOf(SAA2.getAaVerdurasFormaAcesso()));
			aaCarneFrequencia.setTextContent(String.valueOf(SAA2.getAaCarneFrequencia()));
			aaCarneFormaAcesso.setTextContent(String.valueOf(SAA2.getAaCarneFormaAcesso()));
			aaOvosFrequencia.setTextContent(String.valueOf(SAA2.getAaOvosFrequencia()));
			aaOvosFormaAcesso.setTextContent(String.valueOf(SAA2.getAaOvosFormaAcesso()));
			aaFarinhasFrequencia.setTextContent(String.valueOf(SAA2.getAaFarinhasFrequencia()));
			aaFarinhasFormaAcesso.setTextContent(String.valueOf(SAA2.getAaFarinhasFormaAcesso()));
			// *** IndSegAlimen
			isaGestante.setTextContent(String.valueOf(SAA2.getIsaGestante()));
			isaGestanteAcompMedico.setTextContent(String.valueOf(SAA2.getIsaGestanteAcompMedico()));
			isaGestanteAcompNutric.setTextContent(String.valueOf(SAA2.getIsaGestanteAcompNutric()));
			isaNutriz.setTextContent(String.valueOf(SAA2.getIsaNutriz()));
			isaNutrizAcompMedico.setTextContent(String.valueOf(SAA2.getIsaNutrizAcompMedico()));
			isaNutrizAcompNutric.setTextContent(String.valueOf(SAA2.getIsaNutrizAcompNutric()));
			isaIntolerancia.setTextContent(String.valueOf(SAA2.getIsaIntolerancia()));
			isaIntoleranciaLactose.setTextContent(String.valueOf(SAA2.getIsaIntoleranciaLactose()));
			isaIntoleranciaGluten.setTextContent(String.valueOf(SAA2.getIsaIntoleranciaGluten()));
			isaIntoleranciaProteina.setTextContent(String.valueOf(SAA2.getIsaIntoleranciaProteina()));
			isaIntoleranciaOutra.setTextContent(String.valueOf(SAA2.getIsaIntoleranciaOutra()));
			isaIntoleranciaAcompMedico.setTextContent(String.valueOf(SAA2.getIsaIntoleranciaAcompMedico()));
			isaIntoleranciaAcompNutric.setTextContent(String.valueOf(SAA2.getIsaIntoleranciaAcompNutric()));
			isaDiabete.setTextContent(String.valueOf(SAA2.getIsaDiabete()));
			isaDiabeteAcompMedico.setTextContent(String.valueOf(SAA2.getIsaDiabeteAcompMedico()));
			isaDiabeteAcompNutric.setTextContent(String.valueOf(SAA2.getIsaDiabeteAcompNutric()));
			isaAnemia.setTextContent(String.valueOf(SAA2.getIsaAnemia()));
			isaAnemiaAcompMedico.setTextContent(String.valueOf(SAA2.getIsaAnemiaAcompMedico()));
			isaAnemiaAcompNutric.setTextContent(String.valueOf(SAA2.getIsaAnemiaAcompNutric()));
			isaHipertensao.setTextContent(String.valueOf(SAA2.getIsaHipertensao()));
			isaHipertensaoAcompMedico.setTextContent(String.valueOf(SAA2.getIsaHipertensaoAcompMedico()));
			isaHipertensaoAcompNutric.setTextContent(String.valueOf(SAA2.getIsaHipertensaoAcompNutric()));
			isaObesidade.setTextContent(String.valueOf(SAA2.getIsaObesidade()));
			isaObesidadeAcompMedico.setTextContent(String.valueOf(SAA2.getIsaObesidadeAcompMedico()));
			isaObesidadeAcompNutric.setTextContent(String.valueOf(SAA2.getIsaObesidadeAcompNutric()));

			// *** atribui os demais elementos como filha do GrupoFamiliar
			// *** geral
			tagGrupoFamiliar.appendChild(SiasN);
			// *** Endereço
			tagGrupoFamiliar.appendChild(eEnd);
			tagGrupoFamiliar.appendChild(eNumero);
			tagGrupoFamiliar.appendChild(eAp);
			tagGrupoFamiliar.appendChild(eBloco);
			tagGrupoFamiliar.appendChild(eComplemento);
			tagGrupoFamiliar.appendChild(eReferencia);
			tagGrupoFamiliar.appendChild(eCEP);
			tagGrupoFamiliar.appendChild(eBairro);
			// *** localizado
			tagGrupoFamiliar.appendChild(lLocalizado);
			tagGrupoFamiliar.appendChild(lMudouse);
			tagGrupoFamiliar.appendChild(lEInexistente);
			tagGrupoFamiliar.appendChild(lSosam);
			// *** AcessoAAlimentacao
			tagGrupoFamiliar.appendChild(aaArrozFrequencia);
			tagGrupoFamiliar.appendChild(aaArrozFormaAcesso);
			tagGrupoFamiliar.appendChild(aaLeiteFrequencia);
			tagGrupoFamiliar.appendChild(aaLeiteFormaAcesso);
			tagGrupoFamiliar.appendChild(aaDerivadosFrequencia);
			tagGrupoFamiliar.appendChild(aaDerivadosFormaAcesso);
			tagGrupoFamiliar.appendChild(aaPaesFrequencia);
			tagGrupoFamiliar.appendChild(aaPaesFormaAcesso);
			tagGrupoFamiliar.appendChild(aaManteigaFrequencia);
			tagGrupoFamiliar.appendChild(aaManteigaFormaAcesso);
			tagGrupoFamiliar.appendChild(aaMacarraoFrequencia);
			tagGrupoFamiliar.appendChild(aaMacarraoFormaAcesso);
			tagGrupoFamiliar.appendChild(aaFubaFrequencia);
			tagGrupoFamiliar.appendChild(aaFubaFormaAcesso);
			tagGrupoFamiliar.appendChild(aaFrutasFrequencia);
			tagGrupoFamiliar.appendChild(aaFrutasFormaAcesso);
			tagGrupoFamiliar.appendChild(aaVerdurasFrequencia);
			tagGrupoFamiliar.appendChild(aaVerdurasFormaAcesso);
			tagGrupoFamiliar.appendChild(aaCarneFrequencia);
			tagGrupoFamiliar.appendChild(aaCarneFormaAcesso);
			tagGrupoFamiliar.appendChild(aaOvosFrequencia);
			tagGrupoFamiliar.appendChild(aaOvosFormaAcesso);
			tagGrupoFamiliar.appendChild(aaFarinhasFrequencia);
			tagGrupoFamiliar.appendChild(aaFarinhasFormaAcesso);
			// *** IndSegAlimen
			tagGrupoFamiliar.appendChild(isaGestante);
			tagGrupoFamiliar.appendChild(isaGestanteAcompMedico);
			tagGrupoFamiliar.appendChild(isaGestanteAcompNutric);
			tagGrupoFamiliar.appendChild(isaNutriz);
			tagGrupoFamiliar.appendChild(isaNutrizAcompMedico);
			tagGrupoFamiliar.appendChild(isaNutrizAcompNutric);
			tagGrupoFamiliar.appendChild(isaIntolerancia);
			tagGrupoFamiliar.appendChild(isaIntoleranciaLactose);
			tagGrupoFamiliar.appendChild(isaIntoleranciaGluten);
			tagGrupoFamiliar.appendChild(isaIntoleranciaProteina);
			tagGrupoFamiliar.appendChild(isaIntoleranciaOutra);
			tagGrupoFamiliar.appendChild(isaIntoleranciaAcompMedico);
			tagGrupoFamiliar.appendChild(isaIntoleranciaAcompNutric);
			tagGrupoFamiliar.appendChild(isaDiabete);
			tagGrupoFamiliar.appendChild(isaDiabeteAcompMedico);
			tagGrupoFamiliar.appendChild(isaDiabeteAcompNutric);
			tagGrupoFamiliar.appendChild(isaAnemia);
			tagGrupoFamiliar.appendChild(isaAnemiaAcompMedico);
			tagGrupoFamiliar.appendChild(isaAnemiaAcompNutric);
			tagGrupoFamiliar.appendChild(isaHipertensao);
			tagGrupoFamiliar.appendChild(isaHipertensaoAcompMedico);
			tagGrupoFamiliar.appendChild(isaHipertensaoAcompNutric);
			tagGrupoFamiliar.appendChild(isaObesidade);
			tagGrupoFamiliar.appendChild(isaObesidadeAcompMedico);
			tagGrupoFamiliar.appendChild(isaObesidadeAcompNutric);
			// *******************MEMBROS******************************************

			Log.v("SocialAlimenta", "gerarXml - MEMBROS iniciado");

			//Cria Elementos da Primeira Intera��o
			Element tagMembros = doc.createElement("MEMBROS");

			//Declara o Membro criando o elemento
			Element tagMembro = null;
			// *** Geral
			Element mSiasN; 
			Element idMembro; 
			// *** Nome
			Element nNome; 
			Element nDNasc;
			Element nNomeMae; 
			Element nNomePai; 
			Element nNaturalCidade; 
			Element nTitular;
			Element nExcluido;
			Element nParentesco;
			// *** Dados Pessoais
			Element dpSexo; 
			Element dpECivil; 
			Element dpEstuda; 
			Element dpCor; 
			Element dpAlfabetiza; 
			Element dpFEscola; 
			Element dpTrabalha;
			Element dpPCD; 

			// *** Documentos
			Element dRG;
			Element dRGExp;
			Element dRGUF;
			Element dRGDExp;
			Element dCPF;
			Element dCPFDExp;
			Element dCTPS;
			Element dCTPSSerie;
			Element dCTPSDExp;
			Element dCTPSUF;
			Element dNIS;
			// *** escolaridade
			Element esEnsino;
			Element esECurso;
			Element esESerie;
			Element esEConcluido;
			Element esEEsp;

			for (Membro MembroColl : SAA2.getMembroCollection() ) {

				// *** Cria a TAG do membro (cada um)
				tagMembro = doc.createElement("MEMBRO");

				// *** Atribui outras tags ao contexto
				// *** Geral
				mSiasN = doc.createElement("mSIASN");
				idMembro = doc.createElement("IDMEMBRO");
				// *** Nome
				nNome = doc.createElement("NOME");
				nDNasc = doc.createElement("DATANASCIMENTO");
				nNomeMae = doc.createElement("NOMEMAE");
				nNomePai = doc.createElement("NOMEPAI");
				nNaturalCidade = doc.createElement("NATURALCIDADE");
				nTitular = doc.createElement("TITULAR");
				nExcluido = doc.createElement("EXCLUIDO");
				nParentesco = doc.createElement("PARENTESCO");
				// *** Dados Pessoais
				dpSexo = doc.createElement("SEXO");
				dpECivil = doc.createElement("ESTADOCIVIL");
				dpEstuda = doc.createElement("ESTUDA");
				dpCor = doc.createElement("COR");
				dpAlfabetiza = doc.createElement("ALFABETIZA");
				dpFEscola = doc.createElement("ESCOLA");
				dpTrabalha = doc.createElement("TRABALHA");
				dpPCD = doc.createElement("PCD");
				// *** Documentos
				dRG = doc.createElement("RG");
				dRGExp = doc.createElement("RGEXP");
				dRGUF = doc.createElement("RGUF");
				dRGDExp = doc.createElement("RGDATAEXP");
				dCPF = doc.createElement("CPF");
				dCPFDExp = doc.createElement("CPFDATAEXP");
				dCTPS = doc.createElement("CTPS");
				dCTPSSerie = doc.createElement("CTPSSERIE");
				dCTPSDExp = doc.createElement("CTPSDATAEXP");
				dCTPSUF = doc.createElement("CTPSUF");
				dNIS = doc.createElement("NIS");
				// *** escolaridade
				esEnsino = doc.createElement("ENSINO");
				esECurso = doc.createElement("CURSO");
				esESerie = doc.createElement("SERIE");
				esEConcluido = doc.createElement("CONCLUIDO");
				esEEsp = doc.createElement("ESPECIAL");


				//Insere os valores nas tags MEMBRO
				mSiasN.setTextContent(String.valueOf(MembroColl.getSiasN()));
				idMembro.setTextContent(String.valueOf(MembroColl.getIdMembro()));
				// *** Nome
				nNome.setTextContent(String.valueOf(MembroColl.getnNome()));
				nDNasc.setTextContent(String.valueOf(MembroColl.getnDNasc()));
				nNomeMae.setTextContent(String.valueOf(MembroColl.getnNomeMae()));
				nNomePai.setTextContent(String.valueOf(MembroColl.getnNomePai()));
				nNaturalCidade.setTextContent(String.valueOf(MembroColl.getnNaturalCidade()));
				nTitular.setTextContent(String.valueOf(MembroColl.getnTitular()));
				nExcluido.setTextContent(String.valueOf(MembroColl.getnExcluido()));
				nParentesco.setTextContent(String.valueOf(MembroColl.getnParentesco()));
				// *** Dados Pessoais
				dpSexo.setTextContent(String.valueOf(MembroColl.getDpSexo()));
				dpECivil.setTextContent(String.valueOf(MembroColl.getDpECivil()));
				dpEstuda.setTextContent(String.valueOf(MembroColl.getDpEstuda()));
				dpCor.setTextContent(String.valueOf(MembroColl.getDpCor()));
				dpAlfabetiza.setTextContent(String.valueOf(MembroColl.getDpAlfabetiza()));
				dpFEscola.setTextContent(String.valueOf(MembroColl.getDpFEscola()));
				dpTrabalha.setTextContent(String.valueOf(MembroColl.getDpTrabalha()));
				dpPCD.setTextContent(String.valueOf(MembroColl.getDpPCD()));
				// *** Documentos
				dRG.setTextContent(String.valueOf(MembroColl.getdRG()));
				dRGExp.setTextContent(String.valueOf(MembroColl.getdRGExp()));
				dRGUF.setTextContent(String.valueOf(MembroColl.getdRGUF()));
				dRGDExp.setTextContent(String.valueOf(MembroColl.getdRGDExp()));
				dCPF.setTextContent(String.valueOf(MembroColl.getdCPF()));
				dCPFDExp.setTextContent(String.valueOf(MembroColl.getdCPFDExp()));
				dCTPS.setTextContent(String.valueOf(MembroColl.getdCTPS()));
				dCTPSSerie.setTextContent(String.valueOf(MembroColl.getdCTPSSerie()));
				dCTPSDExp.setTextContent(String.valueOf(MembroColl.getdCTPSDExp()));
				dCTPSUF.setTextContent(String.valueOf(MembroColl.getdCTPSUF()));
				dNIS.setTextContent(String.valueOf(MembroColl.getdNIS()));
				// *** escolaridade
				esEnsino.setTextContent(String.valueOf(MembroColl.getEsEnsino()));
				esECurso.setTextContent(String.valueOf(MembroColl.getEsECurso()));
				esESerie.setTextContent(String.valueOf(MembroColl.getEsESerie()));
				esEConcluido.setTextContent(String.valueOf(MembroColl.getEsEConcluido()));
				esEEsp.setTextContent(String.valueOf(MembroColl.getEsEEsp()));

				// *** atribui os demais elementos como filha do MEMBRO
				tagMembro.appendChild(mSiasN);
				tagMembro.appendChild(idMembro);
				// *** Nome
				tagMembro.appendChild(nNome);
				tagMembro.appendChild(nDNasc);
				tagMembro.appendChild(nNomeMae);
				tagMembro.appendChild(nNomePai);
				tagMembro.appendChild(nNaturalCidade);
				tagMembro.appendChild(nTitular);
				tagMembro.appendChild(nExcluido);
				tagMembro.appendChild(nParentesco);
				// *** Dados Pessoais
				tagMembro.appendChild(dpSexo);
				tagMembro.appendChild(dpECivil);
				tagMembro.appendChild(dpEstuda);
				tagMembro.appendChild(dpCor);
				tagMembro.appendChild(dpAlfabetiza);
				tagMembro.appendChild(dpFEscola);
				tagMembro.appendChild(dpTrabalha);
				tagMembro.appendChild(dpPCD);
				// *** Documentos
				tagMembro.appendChild(dRG);
				tagMembro.appendChild(dRGExp);
				tagMembro.appendChild(dRGUF);
				tagMembro.appendChild(dRGDExp);
				tagMembro.appendChild(dCPF);
				tagMembro.appendChild(dCPFDExp);
				tagMembro.appendChild(dCTPS);
				tagMembro.appendChild(dCTPSSerie);
				tagMembro.appendChild(dCTPSDExp);
				tagMembro.appendChild(dCTPSUF);
				tagMembro.appendChild(dNIS);
				// *** escolaridade
				tagMembro.appendChild(esEnsino);
				tagMembro.appendChild(esECurso);
				tagMembro.appendChild(esESerie);
				tagMembro.appendChild(esEConcluido);
				tagMembro.appendChild(esEEsp);


				// **********************TRABALHOS***************************************

				Log.v("SocialAlimenta", "gerarXml - TRABALHOS iniciado");

				//Cria Elementos da Primeira Intera��o
				Element tagTrabalhos = doc.createElement("TRABALHOS");

				//Declara o TRABALHO criando o elemento
				Element tagTrabalho = null;

				//Element Trabalha; 
				Element Tipo;
				Element rendimento;
				Element horasMes;
				Element Ocupacao;
				Element INSS;
				Element tSiasN;
				Element tidMembro;


				for (Trabalho TrabalhoColl : MembroColl.getTrabalhoCollection()) {

					// *** Cria a TAG do membro (cada um)
					tagTrabalho = doc.createElement("TRABALHO");


					// *** Atribui outras tags ao contexto
					//Trabalha = doc.createElement("TRABALHA");
					Tipo = doc.createElement("TIPO");
					rendimento = doc.createElement("RENDIMENTO");
					horasMes = doc.createElement("HORASMES");
					Ocupacao = doc.createElement("OCUPACAO");
					INSS = doc.createElement("INSS");
					tSiasN = doc.createElement("tSIASN");
					tidMembro = doc.createElement("tIDMEMBRO");

					//Insere os valores nas tags TRABALHO
					//Trabalha.setTextContent(String.valueOf(TrabalhoColl.getTrabalha()));
					Tipo.setTextContent(String.valueOf(TrabalhoColl.getTipo()));
					rendimento.setTextContent(String.valueOf(TrabalhoColl.getRendimento()));
					horasMes.setTextContent(String.valueOf(TrabalhoColl.getHorasMes()));
					Ocupacao.setTextContent(String.valueOf(TrabalhoColl.getOcupacao()));
					INSS.setTextContent(String.valueOf(TrabalhoColl.getINSS()));
					tSiasN.setTextContent(String.valueOf(TrabalhoColl.gettSiasN()));
					tidMembro.setTextContent(String.valueOf(TrabalhoColl.getTidMembro()));

					// *** atribui os demais elementos como filha do TRABALHO
					//tagTrabalho.appendChild(Trabalha);
					tagTrabalho.appendChild(Tipo);
					tagTrabalho.appendChild(rendimento);
					tagTrabalho.appendChild(horasMes);
					tagTrabalho.appendChild(Ocupacao);
					tagTrabalho.appendChild(INSS);
					tagTrabalho.appendChild(tSiasN);
					tagTrabalho.appendChild(tidMembro);

					Log.v("SocialAlimenta", "gerarXml - tagTrabalhos.appendChild");

					// *** define a tag grupofamiliar como tag filha de GruposFamiliares
					tagTrabalhos.appendChild(tagTrabalho);

				} 

				// ***************TRABALHOSOFR**********************************************

				Log.v("SocialAlimenta", "gerarXml - TRABALHOSOFR iniciado");

				//Cria Elementos da Primeira Intera��o
				Element tagTrabalhosOFR = doc.createElement("TRABALHOSOFR");

				//Declara o TRABALHO criando o elemento
				Element tagTrabalhoOFR = null;

				Element tofrSiasN; 
				Element tofridMembro;
				Element tofrFonte;
				Element tofrValor;
				Element tofrComprovante;


				for (TrabalhoOFR TrabalhoOFRColl : MembroColl.getTrabalhoOFRCollection()) {

					// *** Cria a TAG do membro (cada um)
					tagTrabalhoOFR = doc.createElement("TRABALHOOFR");


					// *** Atribui outras tags ao contexto
					tofrSiasN = doc.createElement("OFRSIASN");
					tofridMembro = doc.createElement("OFRIDMEMBRO");
					tofrFonte = doc.createElement("OFRFONTE");
					tofrValor = doc.createElement("OFRVALOR");
					tofrComprovante = doc.createElement("OFRCOMPROVANTE");


					//Insere os valores nas tags TRABALHO
					tofrSiasN.setTextContent(String.valueOf(TrabalhoOFRColl.getSiasN()));
					tofridMembro.setTextContent(String.valueOf(TrabalhoOFRColl.getIdMembro()));
					tofrFonte.setTextContent(String.valueOf(TrabalhoOFRColl.getFonte()));
					tofrValor.setTextContent(String.valueOf(TrabalhoOFRColl.getValor()));
					tofrComprovante.setTextContent(String.valueOf(TrabalhoOFRColl.getComprovante()));


					// *** atribui os demais elementos como filha do TRABALHO
					tagTrabalhoOFR.appendChild(tofrSiasN);
					tagTrabalhoOFR.appendChild(tofridMembro);
					tagTrabalhoOFR.appendChild(tofrFonte);
					tagTrabalhoOFR.appendChild(tofrValor);
					tagTrabalhoOFR.appendChild(tofrComprovante);

					Log.v("SocialAlimenta", "gerarXml - tagTrabalhosOFR.appendChild");

					// *** define a tag grupofamiliar como tag filha de GruposFamiliares
					tagTrabalhosOFR.appendChild(tagTrabalhoOFR);

				} 
				Log.v("SocialAlimenta", "gerarXml - tagMembro.appendChild");

				// *** define a tag tagTrabalhosOFR como tag filha de tagMembro
				tagMembro.appendChild(tagTrabalhosOFR);

				Log.v("SocialAlimenta", "gerarXml - tagMembro.appendChild");

				// *** define a tag tagTrabalhos como tag filha de tagMembro
				tagMembro.appendChild(tagTrabalhos);

				Log.v("SocialAlimenta", "gerarXml - tagMembros.appendChild");

				// *** define a tag tagMembro como tag filha de tagMembros
				tagMembros.appendChild(tagMembro);

			}
			Log.v("SocialAlimenta", "gerarXml - tagGrupoFamiliar.appendChild");

			// *** define a tag tagMembros como tag filha de tagGrupoFamiliar
			tagGrupoFamiliar.appendChild(tagMembros);

			Log.v("SocialAlimenta", "gerarXml - tagGruposFamiliares.appendChild");

			// *** define a tagGrupoFamiliar como tag filha de tagGruposFamiliares
			tagGruposFamiliares.appendChild(tagGrupoFamiliar);



			/**
			 * NOTES: Não adianta gerar um appendChild quando a classe a 
			 * ser inserida ainda Não contiver suas tags filhas
			 * *
			 */
		}
		Log.v("SocialAlimenta", "gerarXml - tagSocialAlimenta.appendChild");

		// *** define a tagGrupoFamiliar como tag filha de tagGruposFamiliares
		tagSocialAlimenta.appendChild(tagGruposFamiliares);

		Log.v("SocialAlimenta", "gerarXml - doc.appendChild");

		//Insere a tag tagSocialAlimenta com as demais tags no objeto Document doc
		doc.appendChild(tagSocialAlimenta);

		//vamos converter o objeto doc
		//em String para salvar no arquivo
		String arquivo = converter(doc);

		Log.v("MainTest", "gerarXml Passou");
		//vamos agora salvar o arquivo xml
		salvarArquivo(arquivo);
	}

	public MainTest(Context context){
		this.context = context;

	}

	/**
	 * FAZ A LEITURA DOS DADOS no BD PARA PREENCHER A ESTRUTURA DO XML
	 * @param nomeArquivo
	 * @throws Exception
	 */
	public void main(String nomeArquivo) throws Exception {
		Log.v("SocialAlimenta", "MainTest - main()");

		Cursor cVerificaC = null;
		Cursor cVerificaSA = null;
		Cursor cVerificaGF = null;
		Cursor cVerificaM = null;
		Cursor cVerificaT = null;
		Cursor cVerificaOFR = null;
		Log.v("SocialAlimenta", "MainTest - main()- Declarou os Cursores");

		SQLiteDatabase BancoDados = exportarDados.BancoDados;
		Log.v("SocialAlimenta", "MainTest - main()- Abriu o BD");

		if (BancoDados.isOpen()){
			Log.v("SocialAlimenta", "MainTest - main()- BancoDados.isOpen()=TRUE");
			long contaCursorC = 0;
			long contaCursorSA = 0;
			long contaCursorGF = 0;
			long contaCursorM = 0;
			long contaCursorT = 0;
			long contaCursorOFR = 0;
			Log.v("SocialAlimenta", "MainTest - main()- Declarou os Contadores");


			//*** SocialAlimentaApp
			SocialAlimentaApp SAapp = new SocialAlimentaApp();
			Log.v("SocialAlimenta", "MainTest - main()- Criado objeto SAapp");

			try{
				// *** Lista todas Familias existentes no sistema alteradas Localizadas ou Não

				String SQLQuery = "Select * from tab_SocialA_Configuracao where _id="+ID;
				Log.v("SocialAlimenta", "MainTest - main() - Atribuiu SQLQuery");

				cVerificaC = BancoDados.rawQuery(SQLQuery, null);
				Log.v("SocialAlimenta", "MainTest - main() - Atribuiu cursor cVerificaSA");

				contaCursorC = cVerificaC.getCount();
				Log.v("SocialAlimenta", "MainTest - main() - contaCursorC:"+contaCursorC);

				cVerificaC.moveToFirst();
				Log.v("SocialAlimenta", "MainTest - main() - cVerificaC.moveToFirst()");

			}catch (Exception e){
				Log.e("SocialAlimenta", "MainTest - main() - C "+e.getMessage());
			}

			SAapp.setrData(cVerificaC.getString(cVerificaC.getColumnIndex("Data")));
			SAapp.setrMatricula(cVerificaC.getString(cVerificaC.getColumnIndex("Matricula")));
			SAapp.setrNome(cVerificaC.getString(cVerificaC.getColumnIndex("Nome")));

			Log.v("SocialAlimenta", "MainTest - main()- Sets SAapp");

			Collection<grupoFamiliar> gfCollection = new ArrayList<grupoFamiliar>();
			//gfCollection = null;
			Log.v("SocialAlimenta", "MainTest - main()- Declarou a gfCollection");

			try{
				// *** Lista todas Familias existentes no sistema alteradas Localizadas ou Não

				String SQLQuery = "Select * from tab_SocialA_Localizado";
				Log.v("SocialAlimenta", "MainTest - main() - Atribuiu SQLQuery");

				cVerificaSA = BancoDados.rawQuery(SQLQuery, null);
				Log.v("SocialAlimenta", "MainTest - main() - Atribuiu cursor cVerificaSA");

				contaCursorSA = cVerificaSA.getCount();
				Log.v("SocialAlimenta", "MainTest - main() - contaCursorSA:"+contaCursorSA);

				cVerificaSA.moveToFirst();
				Log.v("SocialAlimenta", "MainTest - main() - cVerificaSA.moveToFirst()");

			}catch (Exception e){
				Log.e("SocialAlimenta", "MainTest - main() - SA "+e.getMessage());
			}
			if (contaCursorSA !=0 ){
				do {	

					Collection<Membro> MCollection = new ArrayList<Membro>();
					Log.v("SocialAlimenta", "MainTest - main()- Declarou a MCollection");
					// *** INICIADO a Criação do Objeto de GruposFamiliares
					try{
						String SQLQuery;
						if (cVerificaSA.getString(cVerificaSA.getColumnIndex("Localizado")).equals("Não")){
							SQLQuery = "Select * " +
									"From tab_SocialA_Endereco E, tab_SocialA_Localizado L "+  
									"WHERE " + 
									"E.SiasN = " +  cVerificaSA.getInt(cVerificaSA.getColumnIndex("SiasN")) +" AND "+
									"E.SiasN=L.SiasN " +
									" ";
						}else{
							SQLQuery = "Select * " +
									"From tab_SocialA_Endereco E, tab_SocialA_Localizado L, tab_SocialA_AcessoAlimen AA, tab_SocialA_IndSegAlimen ISA "+  
									"WHERE " + 
									"E.SiasN = " +  cVerificaSA.getInt(cVerificaSA.getColumnIndex("SiasN")) +" AND "+
									"E.SiasN=AA.SiasN AND " +
									"E.SiasN=ISA.SiasN AND " +
									"E.SiasN=L.SiasN " +
									" ";
						}
						Log.v("SocialAlimenta", "MainTest - main() - Atribuiu SQLQuery:" + SQLQuery);

						cVerificaGF = BancoDados.rawQuery(SQLQuery, null);
						Log.v("SocialAlimenta", "MainTest - main() - Atribuiu cursor cVerificaGF");

						contaCursorGF = cVerificaGF.getCount();
						Log.v("SocialAlimenta", "MainTest - main() - contaCursorGF:"+contaCursorGF);

						cVerificaGF.moveToFirst();
						Log.v("SocialAlimenta", "MainTest - main() - cVerificaGF.moveToFirst()");

					}catch (Exception e){
						Log.e("SocialAlimenta", "MainTest - main() - GF "+e.getMessage());
					}

					if (contaCursorGF !=0 ){
						Log.v("SocialAlimenta", "MainTest - main() contaCursorGF !=0 ="+contaCursorGF);

						do {	
							// *** INICIADO a Criação do arquivo auto de MEMBROS
							try{
								String SQLQuery = "Select * " +
										"FROM tab_SocialA_GrupoFamiliar GF, tab_SocialA_DadosPessoais DP, tab_SocialA_Documentos D, tab_SocialA_Escolaridade E, tab_SocialA_Nome N "+  
										"WHERE " + 
										"GF.SiasN = " + cVerificaGF.getInt(cVerificaGF.getColumnIndex("SiasN")) +" AND "+
										//"GF.idMembro = " + cVerificaGF.getInt(cVerificaGF.getColumnIndex("idMembro")) +" AND "+
										"GF.SiasN = D.SiasN AND GF.[SiasN] = DP.[SiasN] AND  GF.SiasN = E.SiasN AND GF.SiasN = N.SiasN AND GF.idMembro = DP.idMembro AND GF.idMembro = D.idMembro AND GF.idMembro = E.idMembro AND GF.idMembro = N.idMembro " +
										" ";
								Log.v("SocialAlimenta", "MainTest - main() - Atribuiu SQLQuery:"+SQLQuery);

								cVerificaM = BancoDados.rawQuery(SQLQuery, null);
								Log.v("SocialAlimenta", "MainTest - main() - Atribuiu cursor cVerificaM");

								contaCursorM = cVerificaM.getCount();
								Log.v("SocialAlimenta", "MainTest - main() - contaCursorM:"+contaCursorM);

								cVerificaM.moveToFirst();
								Log.v("SocialAlimenta", "MainTest - main() - cVerificaM.moveToFirst()");


							}catch (Exception e){
								Log.e("SocialAlimenta", "MainTest - main() M -"+e.getMessage());

							}
							if (contaCursorM !=0 ){
								do {
									Collection<Trabalho> TCollection = new ArrayList<Trabalho>();
									Log.v("SocialAlimenta", "MainTest - main()- Declarou a TCollection");
									// *** INICIADO a Criação do arquivo auto de Trabalho
									try{
										String SQLQuery = "Select * " +
												" From tab_SocialA_Trabalho "+  
												" WHERE " + 
												" SiasN = "+ cVerificaGF.getInt(cVerificaGF.getColumnIndex("SiasN")) +" AND "+
												" idMembro = " +cVerificaM.getInt(cVerificaM.getColumnIndex("idMembro"))+
												" ";
										Log.v("SocialAlimenta", "MainTest - main() - Atribuiu SQLQuery:"+SQLQuery);

										cVerificaT = BancoDados.rawQuery(SQLQuery, null);
										Log.v("SocialAlimenta", "MainTest - main() - Atribuiu cursor cVerificaT");

										contaCursorT = cVerificaT.getCount();
										Log.v("SocialAlimenta", "MainTest - main() - contaCursorT:"+contaCursorT);

										cVerificaT.moveToFirst();
										Log.v("SocialAlimenta", "MainTest - main() - cVerificaT.moveToFirst()");

									}catch (Exception e){
										Log.e("SocialAlimenta", "MainTest - main() T-"+e.getMessage());

									}
									if (contaCursorT !=0 ){
										do {
											//*** Atribui um valor para cada item do objeto
											Trabalho T = null;
											T = new Trabalho();
											Log.v("SocialAlimenta", "Criado objeto T ");

											// *** Atribui sets aos campos do BD
											T.setHorasMes(cVerificaT.getString(cVerificaT.getColumnIndex("HorasporMes")));
											T.setINSS(cVerificaT.getString(cVerificaT.getColumnIndex("INSS")));
											T.setOcupacao(cVerificaT.getString(cVerificaT.getColumnIndex("Ocupacao")));
											T.setRendimento(cVerificaT.getString(cVerificaT.getColumnIndex("Rendimento")));
											T.setTipo(cVerificaT.getString(cVerificaT.getColumnIndex("Tipo")));
											//T.setTrabalha(cVerificaT.getString(cVerificaT.getColumnIndex("Trabalha")));
											T.settSiasN(cVerificaT.getString(cVerificaT.getColumnIndex("SiasN")));
											T.setTidMembro(cVerificaT.getString(cVerificaT.getColumnIndex("idMembro")));

											//** Atribui o objeto � coleção correspondente
											TCollection.add(T);
											Log.v("SocialAlimenta", "MainTest - Inseriu T em TCollection");

										} while(cVerificaT.moveToNext());
									}else{
										Log.v("SocialAlimenta", "MainTest - main - contaCursorT="+contaCursorT);
									}
									Collection<TrabalhoOFR> TOFRCollection = new ArrayList<TrabalhoOFR>();
									Log.v("SocialAlimenta", "MainTest - main()- Declarou a TOFRCollection");
									// *** INICIADO a Criação do arquivo auto de TrabalhoOFR
									try{
										String SQLQuery = "Select * " +
												" From tab_SocialA_TrabalhoOFR "+  
												" WHERE " + 
												" SiasN = " + cVerificaGF.getInt(cVerificaGF.getColumnIndex("SiasN")) +" AND "+
												" idMembro = " +cVerificaM.getInt(cVerificaM.getColumnIndex("idMembro"))+
												" ";
										Log.v("SocialAlimenta", "MainTest - main() - Atribuiu SQLQuery:"+SQLQuery);

										cVerificaOFR = BancoDados.rawQuery(SQLQuery, null);
										Log.v("SocialAlimenta", "MainTest - main() - Atribuiu cursor cVerificaOFR");

										contaCursorOFR = cVerificaOFR.getCount();
										Log.v("SocialAlimenta", "MainTest - main() - contaCursorOFR:"+contaCursorOFR);

										cVerificaOFR.moveToFirst();
										Log.v("SocialAlimenta", "MainTest - main() - cVerificaT.moveToFirst()");

									}catch (Exception e){
										Log.e("SocialAlimenta", "MainTest - main() OFR-"+e.getMessage());

									}
									if (contaCursorOFR !=0 ){
										do {
											//*** Atribui um valor para cada item do objeto
											TrabalhoOFR TORF = new TrabalhoOFR();
											Log.v("SocialAlimenta", "Criado objeto TORF");

											// *** Atribuido os sets as variáveis
											TORF.setComprovante(cVerificaOFR.getString(cVerificaOFR.getColumnIndex("Comprovante")));
											TORF.setFonte(cVerificaOFR.getString(cVerificaOFR.getColumnIndex("Fonte")));
											TORF.setIdMembro(cVerificaOFR.getString(cVerificaOFR.getColumnIndex("idMembro")));
											TORF.setSiasN(cVerificaOFR.getString(cVerificaOFR.getColumnIndex("SiasN")));
											TORF.setValor(cVerificaOFR.getString(cVerificaOFR.getColumnIndex("Valor")));

											//*** Atribui o objeto � coleção correspondente

											TOFRCollection.add(TORF);

											Log.v("SocialAlimenta", "MainTest - Inseriu TORF em TOFRCollection");

										} while(cVerificaOFR.moveToNext());
									}else{
										Log.e("SocialAlimenta", "MainTest - main() - contaCursorOFR="+contaCursorOFR);
									}

									//*** Membro
									Membro M = new Membro();
									Log.v("SocialAlimenta", "Criado objeto Membro");
									// *** Geral
									M.setIdMembro(cVerificaM.getInt(cVerificaM.getColumnIndex("idMembro")));
									M.setSiasN(cVerificaM.getInt(cVerificaM.getColumnIndex("SiasN")));
									// *** NOME
									M.setnNome(cVerificaM.getString(cVerificaM.getColumnIndex("Nome")));
									M.setnDNasc(cVerificaM.getString(cVerificaM.getColumnIndex("DNasc")));
									M.setnNaturalCidade(cVerificaM.getString(cVerificaM.getColumnIndex("NaturalCidade")));
									M.setnNomeMae(cVerificaM.getString(cVerificaM.getColumnIndex("NomeMae")));
									M.setnNomePai(cVerificaM.getString(cVerificaM.getColumnIndex("NomePai")));
									M.setnExcluido(cVerificaM.getString(cVerificaM.getColumnIndex("Excluido")));
									M.setnTitular(cVerificaM.getString(cVerificaM.getColumnIndex("Titular")));
									M.setnParentesco(cVerificaM.getString(cVerificaM.getColumnIndex("Parentesco")));
									// *** DADOSPESSOAIS
									M.setDpSexo(cVerificaM.getString(cVerificaM.getColumnIndex("Sexo")));
									M.setDpECivil(cVerificaM.getString(cVerificaM.getColumnIndex("EstCivil")));
									M.setDpEstuda(cVerificaM.getString(cVerificaM.getColumnIndex("Estuda")));
									M.setDpCor(cVerificaM.getString(cVerificaM.getColumnIndex("Cor")));
									M.setDpAlfabetiza(cVerificaM.getString(cVerificaM.getColumnIndex("Alfabetiza")));
									M.setDpFEscola(cVerificaM.getString(cVerificaM.getColumnIndex("FreqEscola")));
									M.setDpTrabalha(cVerificaM.getString(cVerificaM.getColumnIndex("Trabalha")));
									M.setDpPCD(cVerificaM.getString(cVerificaM.getColumnIndex("PCD")));
									// *** DOCUMENTOS
									M.setdRG(cVerificaM.getString(cVerificaM.getColumnIndex("RG")));
									M.setdRGExp(cVerificaM.getString(cVerificaM.getColumnIndex("RGExp")));
									M.setdRGDExp(cVerificaM.getString(cVerificaM.getColumnIndex("RGDataExp")));
									M.setdRGUF(cVerificaM.getString(cVerificaM.getColumnIndex("RGUF")));
									M.setdCPF(cVerificaM.getString(cVerificaM.getColumnIndex("CPF")));
									M.setdCPFDExp(cVerificaM.getString(cVerificaM.getColumnIndex("CPFDataExp")));
									M.setdCTPS(cVerificaM.getString(cVerificaM.getColumnIndex("CTPS")));
									M.setdCTPSSerie(cVerificaM.getString(cVerificaM.getColumnIndex("CTPSSerie")));
									M.setdCTPSDExp(cVerificaM.getString(cVerificaM.getColumnIndex("CTPSDataExp")));
									M.setdCTPSUF(cVerificaM.getString(cVerificaM.getColumnIndex("CTPSUF")));
									M.setdNIS(cVerificaM.getString(cVerificaM.getColumnIndex("NIS")));
									// *** ESCOLARIDADE
									M.setEsEnsino(cVerificaM.getString(cVerificaM.getColumnIndex("Ensino")));
									M.setEsECurso(cVerificaM.getString(cVerificaM.getColumnIndex("EnsCurso")));
									M.setEsESerie(cVerificaM.getString(cVerificaM.getColumnIndex("EnsSerie")));
									M.setEsEConcluido(cVerificaM.getString(cVerificaM.getColumnIndex("EnsConcluido")));
									M.setEsEEsp(cVerificaM.getString(cVerificaM.getColumnIndex("EnsEsp")));

									Log.v("SocialAlimenta", "MainTest - main - Sets em Campos de M");
									// *** TRABALHO
									M.setTrabalhoCollection(TCollection);
									Log.v("SocialAlimenta", "MainTest - main - Inseriu TCollection em M");

									// *** TRABALHO
									M.setTrabalhoOFRCollection(TOFRCollection);
									Log.v("SocialAlimenta", "MainTest - main - Inseriu TOFRCollection em M");

									MCollection.add(M);
									Log.v("SocialAlimenta", "MainTest - Inseriu M em MCollection");

								} while(cVerificaM.moveToNext());
							}else{
								Log.e("SocialAlimenta", "MainTest - main - contaCursorM="+contaCursorM);
							}

							//*** grupoFamiliar
							grupoFamiliar gf = new grupoFamiliar();
							Log.v("SocialAlimenta", "Criado objeto gf");

							// *** Geral
							gf.setSiasN(cVerificaGF.getInt(cVerificaGF.getColumnIndex("SiasN")));
							// *** Endereco ***
							gf.seteEndereco(cVerificaGF.getString(cVerificaGF.getColumnIndex("Endereco")));
							gf.seteNumero(cVerificaGF.getString(cVerificaGF.getColumnIndex("numero")));
							gf.seteAp(cVerificaGF.getString(cVerificaGF.getColumnIndex("Ap")));
							gf.seteBloco(cVerificaGF.getString(cVerificaGF.getColumnIndex("Bloco")));
							gf.seteComplemento(cVerificaGF.getString(cVerificaGF.getColumnIndex("Complemento")));
							gf.seteReferencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("Referencia")));
							gf.seteCEP(cVerificaGF.getString(cVerificaGF.getColumnIndex("CEP")));
							gf.seteBairro(cVerificaGF.getString(cVerificaGF.getColumnIndex("Bairro")));
							// *** localizado
							gf.setlLocalizado(cVerificaGF.getString(cVerificaGF.getColumnIndex("Localizado")));
							gf.setlMudouse(cVerificaGF.getString(cVerificaGF.getColumnIndex("Mudouse")));
							gf.setlEInexistente(cVerificaGF.getString(cVerificaGF.getColumnIndex("EndInex")));
							gf.setlSosam(cVerificaGF.getString(cVerificaGF.getColumnIndex("Sosam")));

							if (cVerificaSA.getString(cVerificaSA.getColumnIndex("Localizado")).equals("Sim")){
								// *** AcessoAAlimentacao
								gf.setAaArrozFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("ArrozFrequencia")));
								gf.setAaArrozFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("ArrozFormaAcesso")));
								gf.setAaLeiteFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("LeiteFrequencia")));
								gf.setAaLeiteFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("LeiteFormaAcesso")));
								gf.setAaDerivadosFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("DerivadosFrequencia")));
								gf.setAaDerivadosFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("DerivadosFormaAcesso")));
								gf.setAaPaesFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("PaesFrequencia")));
								gf.setAaPaesFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("PaesFormaAcesso")));
								gf.setAaManteigaFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("ManteigaFrequencia")));
								gf.setAaManteigaFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("ManteigaFormaAcesso")));
								gf.setAaMacarraoFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("MacarraoFrequencia")));
								gf.setAaMacarraoFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("MacarraoFormaAcesso")));
								gf.setAaFubaFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("FubaFrequencia")));
								gf.setAaFubaFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("FubaFormaAcesso")));
								gf.setAaFrutasFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("FrutasFrequencia")));
								gf.setAaFrutasFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("FrutasFormaAcesso")));
								gf.setAaVerdurasFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("VerdurasFrequencia")));
								gf.setAaVerdurasFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("VerdurasFormaAcesso")));
								gf.setAaCarneFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("CarneFrequencia")));
								gf.setAaCarneFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("CarneFormaAcesso")));
								gf.setAaOvosFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("OvosFrequencia")));
								gf.setAaOvosFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("OvosFormaAcesso")));
								gf.setAaFarinhasFrequencia(cVerificaGF.getString(cVerificaGF.getColumnIndex("FarinhasFrequencia")));
								gf.setAaFarinhasFormaAcesso(cVerificaGF.getString(cVerificaGF.getColumnIndex("FarinhasFormaAcesso")));
								// *** IndSegAlimen
								gf.setIsaGestante(cVerificaGF.getString(cVerificaGF.getColumnIndex("Gestante")));
								gf.setIsaGestanteAcompMedico(cVerificaGF.getString(cVerificaGF.getColumnIndex("GestanteAcompMedico")));
								gf.setIsaGestanteAcompNutric(cVerificaGF.getString(cVerificaGF.getColumnIndex("GestanteAcompNutric")));
								gf.setIsaNutriz(cVerificaGF.getString(cVerificaGF.getColumnIndex("Nutriz")));
								gf.setIsaNutrizAcompMedico(cVerificaGF.getString(cVerificaGF.getColumnIndex("NutrizAcompMedico")));
								gf.setIsaNutrizAcompNutric(cVerificaGF.getString(cVerificaGF.getColumnIndex("NutrizAcompNutric")));
								gf.setIsaIntolerancia(cVerificaGF.getString(cVerificaGF.getColumnIndex("Intolerancia")));
								gf.setIsaIntoleranciaGluten(cVerificaGF.getString(cVerificaGF.getColumnIndex("IntoleranciaGluten")));
								gf.setIsaIntoleranciaLactose(cVerificaGF.getString(cVerificaGF.getColumnIndex("IntoleranciaLactose")));
								gf.setIsaIntoleranciaProteina(cVerificaGF.getString(cVerificaGF.getColumnIndex("IntoleranciaProteina")));
								gf.setIsaIntoleranciaOutra(cVerificaGF.getString(cVerificaGF.getColumnIndex("IntoleranciaOutra")));
								gf.setIsaIntoleranciaAcompMedico(cVerificaGF.getString(cVerificaGF.getColumnIndex("IntoleranciaAcompMedico")));
								gf.setIsaIntoleranciaAcompNutric(cVerificaGF.getString(cVerificaGF.getColumnIndex("IntoleranciaAcompNutric")));
								gf.setIsaDiabete(cVerificaGF.getString(cVerificaGF.getColumnIndex("Diabete")));
								gf.setIsaDiabeteAcompMedico(cVerificaGF.getString(cVerificaGF.getColumnIndex("DiabeteAcompMedico")));
								gf.setIsaDiabeteAcompNutric(cVerificaGF.getString(cVerificaGF.getColumnIndex("DiabeteAcompNutric")));
								gf.setIsaAnemia(cVerificaGF.getString(cVerificaGF.getColumnIndex("Anemia")));
								gf.setIsaAnemiaAcompMedico(cVerificaGF.getString(cVerificaGF.getColumnIndex("AnemiaAcompMedico")));
								gf.setIsaAnemiaAcompNutric(cVerificaGF.getString(cVerificaGF.getColumnIndex("AnemiaAcompNutric")));
								gf.setIsaHipertensao(cVerificaGF.getString(cVerificaGF.getColumnIndex("Hipertensao")));
								gf.setIsaHipertensaoAcompMedico(cVerificaGF.getString(cVerificaGF.getColumnIndex("HipertensaoAcompMedico")));
								gf.setIsaHipertensaoAcompNutric(cVerificaGF.getString(cVerificaGF.getColumnIndex("HipertensaoAcompNutric")));
								gf.setIsaObesidade(cVerificaGF.getString(cVerificaGF.getColumnIndex("Obesidade")));
								gf.setIsaObesidadeAcompMedico(cVerificaGF.getString(cVerificaGF.getColumnIndex("ObesidadeAcompMedico")));
								gf.setIsaObesidadeAcompNutric(cVerificaGF.getString(cVerificaGF.getColumnIndex("ObesidadeAcompNutric")));
							}else{
								Log.i(TAG, "If de familia Não Localizada");
							}
							gf.setMembroCollection(MCollection);
							Log.v("SocialAlimenta", "MainTest - Inseriu MCollection em gf.setMembroCollection");

							gfCollection.add(gf);
							Log.v("SocialAlimenta", "MainTest - Inseriu gf em gfCollection");

						} while(cVerificaGF.moveToNext());
					}else{
						Log.e("SocialAlimenta", "MainTest - main - contaCursorGF="+contaCursorGF);
					}
					//gerarXmlXStream(gfCollection);
				} while(cVerificaSA.moveToNext());
			}else{
				Log.e("SocialAlimenta", "MainTest - main() - contaCursorSA="+contaCursorSA);
			}
			//*** SocialAlimentaApp
			SAapp.setGrupoFamiliarCollection(gfCollection);
			Log.v("SocialAlimenta", "MainTest - main - Inseriu gfCollection em SAapp");

			try {
				Log.v("SocialAlimenta", "MainTest - main - Try Gerar XML");

				gerarXml(SAapp,nomeArquivo);
				Log.v("SocialAlimenta", "GerarXML - Gerou");


			} catch (ParserConfigurationException e) {
				//e.printStackTrace();
				Log.e("SocialAlimenta", "MainTest - ERRO ParserConfigurationException: "+e.getMessage());

			} catch (TransformerException e) {
				//e.printStackTrace();
				Log.e("SocialAlimenta", "MainTest - ERRO TransformerException: "+e.getMessage());

			} catch (Exception e) {
				// e.printStackTrace();
				Log.e("SocialAlimenta", "MainTest - ERRO Exception: "+e.getMessage());
			}



		}else{
			Log.e("SocialAlimenta", "MainTest - main() - ERRO: BD Não aberto");

		}
	}

	/**
	 * EM USO
	 * @param elem
	 * @param tagName
	 * @return child.getTextContent or Null
	 * @throws Exception
	 * @tutorial http://mballem.wordpress.com/2011/04/22/manipulando-arquivo-xml-%E2%80%93-parte-i-api-nativa/
	 */
	public static String getChildTagValue(Element elem, String tagName) throws Exception {
		NodeList children = elem.getElementsByTagName(tagName);
		String result = null;
		//children � a tag pai que estamos lendo, 
		// por exemplo a tag &lt;Endereco&gt;
		if (children == null) {
			Log.v("MainTest", "getChildTagValue - children == null");
			return result;
		}
		//child � a tag que queremos recuperar o valor, por exemplo
		//a tag &lt;cidade&gt;
		Element child = (Element) children.item(0);

		if (child == null) {
			Log.v("MainTest", "getChildTagValue - child == null");
			return result;
		}
		//recuperamos o texto contido na tagName    
		result = child.getTextContent();

		return result;
	}

	/**
	 * L� O XML E GRAVA TUDO NAS CLASSES
	 * @return SocialAlimentaApp
	 * @throws Exception e, err
	 * @throws SAXException e
	 * @throws TransformerException e
	 * @tutorial http://mballem.wordpress.com/2011/04/22/manipulando-arquivo-xml-%E2%80%93-parte-i-api-nativa/
	 * @tutorial http://stackoverflow.com/questions/2104879/parsing-xml-truncates-file-path
	 */
	public void lerXml() throws Exception, SAXException, TransformerException {

		DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
		DocumentBuilder db = dbf.newDocumentBuilder();

		// *** baixar o arquivo
		// colocar o arquivo no FILE
		String NomeArquivo = "socialAlimenta";

		EnviarArquivoFTP dftp = new EnviarArquivoFTP();
		if (dftp.downloadFTP(
				//"189.38.80.49", "celebrandoavida", "9qw16chn", "socialAlimenta/Novo", 
				//"10.1.30.1", "ntadm/social.alimenta", "so1234", "tablet_ftp",
				"10.1.30.1", "ntadm/social.alimenta", "so1234", "tablet_ftp/Novo",
				"/data/data/br.gov.sjc.socialalimenta/files/",NomeArquivo+".xml")){
			Log.i("lerXml", "Nome do arquivo:"+NomeArquivo+".xml");
		}else{
			Log.e("lerXml", "ERRO: Não Baixou o Arquivo");
			Toast.makeText(context, "Não baixou o arquivo corretamente", Toast.LENGTH_LONG).show();
		}
		//Recupera o caminho padr�o do SDCARD
		//File root = Environment.getExternalStorageDirectory();

		//Informamos qual arquivo xml vamos ler
		Document doc = null;
		try{
			doc = db.parse(new InputSource(new FileReader(file.toString())));
		}catch(Exception e){
			Log.e(TAG, "ERRO: "+e.getMessage());
			
		}
		//Informamos qual arquivo xml vamos ler do SD
		//Document doc = db.parse(new InputSource(root+"/socialAlimenta/socialAlimenta.xml"));


		//Criamos um objeto Element que receberá as informações de doc
		Element socialAlimenta = doc.getDocumentElement();
		Log.i("lerXml", "Criamos um objeto Element que receberá as informações de doc");


		// *** Cria a Coleção grupoFamiliarCollection
		Collection<grupoFamiliar> grupoFamiliarCollection = new ArrayList<grupoFamiliar>();
		NodeList GFsList = socialAlimenta.getElementsByTagName("GRUPOFAMILIAR");
		Element grupoFamiliar;
		Log.i("lerXml", "Criamos a Coleção grupoFamiliarCollection");
		
		DestroiDatabase dp = new DestroiDatabase(context);
		Log.i(TAG,"DestroiDatabase="+dp.toString());

		//Fazemos um for nas tags GRUPOSFAMILIARES e adicionamos os dados
		//  em um objeto grupoFamiliar e depois na coleção
		for (int i = 0; i < GFsList.getLength(); i++) {
			grupoFamiliar = (Element) GFsList.item(i);
			grupoFamiliar gf = new grupoFamiliar();
			Endereco end = new Endereco();
			Log.i("lerXml", "Criamos os objetos de GF e End");
			
			

			// *** GERAL
			gf.setSiasN(Integer.parseInt(getChildTagValue(grupoFamiliar, "SIASN")));
			end.setSiasN(gf.getSiasN());
			Log.i("lerXml", "Criamos SIASN:"+gf.getSiasN());
			//Toast.makeText(context, "Gravando Dados da Família:"+gf.getSiasN(), Toast.LENGTH_LONG).show();
			// *** ENDERECO
			gf.seteEndereco(getChildTagValue(grupoFamiliar, "ENDERECO"));
			end.setEndereco(gf.geteEndereco());
			gf.seteNumero(getChildTagValue(grupoFamiliar, "NUMERO"));
			end.setNumero(gf.geteNumero());
			gf.seteAp(getChildTagValue(grupoFamiliar, "AP"));
			end.setAp(gf.geteAp());
			gf.seteBloco(getChildTagValue(grupoFamiliar, "BLOCO"));
			end.setBloco(gf.geteBloco());
			gf.seteComplemento(getChildTagValue(grupoFamiliar, "COMPLEMENTO"));
			end.setComplemento(gf.geteComplemento());
			gf.seteReferencia(getChildTagValue(grupoFamiliar, "REFERENCIA"));
			end.setReferencia(gf.geteReferencia());
			gf.seteCEP(getChildTagValue(grupoFamiliar, "CEP"));
			end.setCEP(gf.geteCEP());
			gf.seteBairro(getChildTagValue(grupoFamiliar, "BAIRRO"));
			end.setBairro(gf.geteBairro());

			//Escreveu no BD
			EnderecoDAO endDao = new EnderecoDAO(context);
			endDao.inserir(end);
			endDao.close();


			// *** LOCALIZADO (Não necessário na leitura)
			// *** ACESSOALIMENTA (Não necessário na leitura) 
			// *** INDSEGALIMENTAR (Não necessário na leitura)

			// *** Cria a Coleção grupoFamiliarCollection
			Collection<Membro> membroCollection = new ArrayList<Membro>();
			NodeList MembrosList = grupoFamiliar.getElementsByTagName("MEMBRO");
			Element Membro;
			//Fazemos um for nas tags MEMBRO e adicionamos os dados
			//  em um objeto Membro e depois na coleção
			for (int j = 0; j < MembrosList.getLength(); j++) {
				Membro = (Element) MembrosList.item(j);
				
				//A classe membro escreve no BD atraves das outras classes menores
				Membro membro = new Membro();
				GrupoFamiliarTable gft = new GrupoFamiliarTable();
				
				// *** geral e GRUPOFAMILIARTABLE
				membro.setSiasN(Integer.parseInt(getChildTagValue(Membro,"mSIASN")));
				gft.setSiasN(membro.getSiasN());
				membro.setIdMembro(Integer.parseInt(getChildTagValue(Membro,"IDMEMBRO")));
				gft.setIdMembro(membro.getIdMembro());
				gft.setDesc(""+membro.getSiasN()+"/"+membro.getIdMembro());

				// insere no BD
				GrupoFamiliarDAO gfdao = new GrupoFamiliarDAO(context);
				gfdao.inserir(gft);
				gfdao.close();
				
				// *** NOME
				// atribui o valor vindo do xml ao objeto
				Nome nomeLer = new Nome();
				nomeLer.setSiasN(membro.getSiasN());
				nomeLer.setIdMembro(membro.getIdMembro());

				membro.setnNome(getChildTagValue(Membro,"NOME"));
				nomeLer.setNome(membro.getnNome());
				membro.setnDNasc(getChildTagValue(Membro,"DATANASCIMENTO"));
				nomeLer.setDNasc(membro.getnDNasc());
				membro.setnNomeMae(getChildTagValue(Membro,"NOMEMAE"));
				nomeLer.setNomeMae(membro.getnNomeMae());
				membro.setnNomePai(getChildTagValue(Membro,"NOMEPAI"));
				nomeLer.setNomePai(membro.getnNomePai());
				membro.setnNaturalCidade(getChildTagValue(Membro,"NATURALCIDADE"));
				nomeLer.setNaturalCidade(membro.getnNaturalCidade());
				membro.setnExcluido(getChildTagValue(Membro,"EXCLUIDO"));
				nomeLer.setExcluido(membro.getnExcluido());
				//Não precisa ler:
				// Titular, Parentesco

				// insere no BD
				NomeDAO ndao = new NomeDAO(context);
				ndao.inserir(nomeLer);
				ndao.close();

				// *** DADOSPESSOAIS
				// atribui o valor vindo do xml ao objeto
				DadosPessoais dpLer = new DadosPessoais();
				dpLer.setSiasN(membro.getSiasN());
				dpLer.setIdMembro(membro.getIdMembro());

				membro.setDpSexo(getChildTagValue(Membro,"SEXO"));
				dpLer.setSexo(membro.getDpSexo());
				membro.setDpECivil(getChildTagValue(Membro,"ESTADOCIVIL"));
				dpLer.setEstCivil(membro.getDpECivil());
				membro.setDpEstuda(getChildTagValue(Membro,"ESTUDA"));
				dpLer.setEstuda(membro.getDpEstuda());
				membro.setDpCor(getChildTagValue(Membro,"COR"));
				dpLer.setCor(membro.getDpCor());
				membro.setDpAlfabetiza(getChildTagValue(Membro,"ALFABETIZA"));
				dpLer.setAlfabetiza(membro.getDpAlfabetiza());
				membro.setDpFEscola(getChildTagValue(Membro,"ESCOLA")); //FREQUENTAESCOLA
				dpLer.setFreqEscola(membro.getDpFEscola());
				membro.setDpPCD(getChildTagValue(Membro,"PCD")); //PCD
				dpLer.setPCD(membro.getDpPCD());

				/* insere no BD */
				DadosPessoaisDAO dpdao = new DadosPessoaisDAO(context);
				dpdao.inserir(dpLer);
				dpdao.close();

				// *** DOCUMENTOS
				// atribui o valor vindo do xml ao objeto
				Documentos docsLer = new Documentos();
				docsLer.setSiasN(membro.getSiasN());
				docsLer.setIdMembro(membro.getIdMembro());

				membro.setdRG(getChildTagValue(Membro,"RG"));
				docsLer.setRG(membro.getdRG());
				membro.setdRGExp(getChildTagValue(Membro,"RGEXP"));
				docsLer.setRGExp(membro.getdRGExp());
				membro.setdRGDExp(getChildTagValue(Membro,"RGDATAEXP"));
				docsLer.setRGDataExp(membro.getdRGDExp());
				membro.setdRGUF(getChildTagValue(Membro,"RGUF"));
				docsLer.setRGUF(membro.getdRGUF());
				membro.setdCPF(getChildTagValue(Membro,"CPF"));
				docsLer.setCPF(membro.getdCPF());
				membro.setdCPFDExp(getChildTagValue(Membro,"CPFDATAEXP"));
				docsLer.setCPFDataExp(membro.getdCPFDExp());
				membro.setdCTPS(getChildTagValue(Membro,"CTPS"));
				docsLer.setCTPS(membro.getdCTPS());
				membro.setdCTPSDExp(getChildTagValue(Membro,"CTPSDATAEXP"));
				docsLer.setCTPSDataExp(membro.getdCTPSDExp());
				membro.setdCTPSSerie(getChildTagValue(Membro,"CTPSSERIE"));
				docsLer.setCTPSSerie(membro.getdCTPSSerie());
				membro.setdCTPSUF(getChildTagValue(Membro,"CTPSUF"));
				docsLer.setCTPSUF(membro.getdCTPSUF());
				//TODO: CIV CTPS EMISSAO ????
				membro.setdNIS(getChildTagValue(Membro,"NIS"));
				docsLer.setNIS(membro.getdNIS());

				/* insere no BD*/
				DocumentosDAO docsdao = new DocumentosDAO(context);
				docsdao.inserir(docsLer);
				docsdao.close();

				// *** ESCOLARIDADE
				// atribui o valor vindo do xml ao objeto
				Escolaridade escLer = new Escolaridade();
				escLer.setSiasN(membro.getSiasN());
				escLer.setIdMembro(membro.getIdMembro());

				membro.setEsEnsino(getChildTagValue(Membro,"ENSINO"));
				escLer.setEnsino(membro.getEsEnsino());
				membro.setEsECurso(getChildTagValue(Membro,"CURSO"));
				escLer.setEnsCurso(membro.getEsECurso());
				membro.setEsESerie(getChildTagValue(Membro,"SERIE"));
				escLer.setEnsSerie(membro.getEsESerie());
				membro.setEsEConcluido(getChildTagValue(Membro,"CONCLUIDO"));
				escLer.setEnsConcluido(membro.getEsEConcluido());
				membro.setEsEEsp(getChildTagValue(Membro,"ESPECIAL"));
				escLer.setEnsEsp(membro.getEsEEsp());

				/* insere no BD */
				EscolaridadeDAO escdao = new EscolaridadeDAO(context);
				escdao.inserir(escLer);
				escdao.close();

				// *** Cria a Coleção grupoFamiliarCollection
				Collection<Trabalho> trabalhoCollection = new ArrayList<Trabalho>();
				NodeList trabalhosList = Membro.getElementsByTagName("TRABALHO");
				Element trabalho;
				//Fazemos um for nas tags MEMBRO e adicionamos os dados
				//  em um objeto Membro e depois na coleção
				for (int k = 0; k < trabalhosList.getLength(); k++) {
					trabalho = (Element) trabalhosList.item(k);
					Trabalho tr = new Trabalho();
					tr.settSiasN(getChildTagValue(trabalho, "tSIASN"));
					tr.setTidMembro(getChildTagValue(trabalho, "tIDMEMBRO"));
					//tr.setTrabalha(getChildTagValue(trabalho, "TRABALHA"));
					tr.setTipo(getChildTagValue(trabalho, "TIPO"));
					tr.setRendimento(getChildTagValue(trabalho, "RENDIMENTO"));
					tr.setHorasMes(getChildTagValue(trabalho, "HORASMES"));
					tr.setOcupacao(getChildTagValue(trabalho, "OCUPACAO"));
					tr.setINSS(getChildTagValue(trabalho, "INSS"));

					trabalhoCollection.add(tr);

					// *** insere o objeto no BD
					TrabalhoDAO trdao = new TrabalhoDAO(context);
					trdao.open();
					if(trdao.inserir(tr)==-1){
						Log.e(TAG,"lerXML - Inserir TrabalhoDAO erro encontrado");
					}
					trdao.close();
				}

				// *** TRABALHO
				membro.setTrabalhoCollection(trabalhoCollection);

				// *** Cria a Coleção grupoFamiliarCollection
				Collection<TrabalhoOFR> trabalhoOFRCollection = new ArrayList<TrabalhoOFR>();
				NodeList trabalhosOFRList = Membro.getElementsByTagName("TRABALHOOFR");
				Element trabalhoOFR;
				//Fazemos um for nas tags MEMBRO e adicionamos os dados
				//  em um objeto Membro e depois na coleção
				for (int l = 0; l < trabalhosOFRList.getLength(); l++) {
					trabalhoOFR = (Element) trabalhosOFRList.item(l);
					TrabalhoOFR trOFR = new TrabalhoOFR();
					trOFR.setSiasN(getChildTagValue(trabalhoOFR, "OFRSIASN"));
					trOFR.setIdMembro(getChildTagValue(trabalhoOFR, "OFRIDMEMBRO"));
					trOFR.setFonte(getChildTagValue(trabalhoOFR, "OFRFONTE"));
					trOFR.setValor(getChildTagValue(trabalhoOFR, "OFRVALOR"));
					trOFR.setComprovante(getChildTagValue(trabalhoOFR, "OFRCOMPROVANTE"));

					trabalhoOFRCollection.add(trOFR);

					// *** insere o objeto no BD
					TrabalhoOFRDAO trOFRdao = new TrabalhoOFRDAO(context);
					trOFRdao.open();
					trOFRdao.inserir(trOFR);
					trOFRdao.close();
				}
				// *** TRABALHOOFR
				membro.setTrabalhoOFRCollection(trabalhoOFRCollection);

				//membroDao.inserir(membro);

				//Adicionamos � coleção, as tags grupoFamiliar
				membroCollection.add(membro);
			}
			gf.setMembroCollection(membroCollection);

			//Adicionamos � coleção, as tags grupoFamiliar
			grupoFamiliarCollection.add(gf);
		}

		// **** Criamos o objeto SocialAlimentaApp
		SocialAlimentaApp SAapp = new SocialAlimentaApp();
		//SAapp.setrData(getChildTagValue(socialAlimenta,"RDATA"));
		//SAapp.setrMatricula(getChildTagValue(socialAlimenta,"RMATRICULA"));
		//SAapp.setrNome(getChildTagValue(socialAlimenta,"RNOME"));
		// *** Atribui o grupoFamiliarCollection a SAapp
		SAapp.setGrupoFamiliarCollection(grupoFamiliarCollection);

		//return SAapp;
		//Toast.makeText(context, "Finalizando Grava��o...", Toast.LENGTH_LONG).show();
	}

	/**
	 * Baixa Arquivo XML do FTP, salva internamente, le o arquivo.
	 * @param nomeArquivo
	 * @return
	 * @throws SocketException
	 * @throws IOException
	 */
	private static SocialAlimentaApp lerXStrean(String nomeArquivo) throws SocketException, IOException{
		EnviarArquivoFTP eaf = new EnviarArquivoFTP();
		boolean resposta = eaf.downloadFTP(
				"189.38.80.49", "celebrandoavida", "9qw16chn", "socialAlimenta", 
				//"10.1.30.1", "ntadm/social.alimenta", "so1234", "tablet_ftp",
				"/data/data/br.gov.sjc.socialalimenta/files/",nomeArquivo);

		FileReader reader = null;
		SocialAlimentaApp SAapp = null;
		String XmlText = "";
		if (resposta){
			FileReader fileReader = null;
			try {
				//Recupera o caminho padr�o do SDCARD
				File root = Environment.getExternalStorageDirectory();

				//Fa�o a leitura do do arquivo 
				fileReader = new FileReader(root+"/socialAlimenta/socialAlimenta.xml");
				BufferedReader leitor= new BufferedReader(fileReader);
				String linha = null;  

				//Loop para ler e inserir no editText
				while((linha = leitor.readLine()) != null) {  
					XmlText+= linha;
				} 
				Log.i("SocialAlimenta","lerXStrean - executado o reader e o XmlText:"+XmlText);

			} catch (FileNotFoundException e) {
				Log.e("SocialAlimenta", "lerXStrean - ERRO:"+e.getMessage()+"---XmlText:"+XmlText);
				//e.printStackTrace();
			}

			//Cria o objeto xstream
			XStream xStream = new XStream(new DomDriver());
			//informamos as tags que ser�o lidas
			//como foi feito no método gerarXml002
			//cria um objeto Contato,
			//contendo os dados do xml
			SAapp = (SocialAlimentaApp) xStream.fromXML(fileReader);

			/*Iterator it = SAapp.iterator();

			while (it.hasNext()) {
			//ProdutosXml pr = (ProdutosXml) it.next();
			pr.getDescricao();
			}*/

			//Exibimos no console o resultado
			Log.e("TAG",""+SAapp.toString());
			Log.v("SocialAlimenta",""+SAapp.toString());
		}else{
			Log.e("SocialAlimenta","Não realizado o Download:"+SAapp.toString());
		}
		return SAapp;
	}
}